//package com.sleep.psy.main_server.utils;
//
//import com.google.common.base.Preconditions;
//import org.apache.commons.lang.StringUtils;
//import org.redisson.api.RAtomicLong;
//import org.redisson.api.RLock;
//import org.redisson.api.RedissonClient;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Component;
//import redis.clients.jedis.Jedis;
//import redis.clients.jedis.JedisPool;
//import redis.clients.jedis.StreamEntryID;
//import redis.clients.jedis.exceptions.JedisConnectionException;
//import redis.clients.jedis.resps.StreamEntry;
//
//import java.util.List;
//import java.util.Map;
//import java.util.Set;
//import java.util.concurrent.TimeUnit;
//import java.util.function.Function;
//
////@Component
//public class JedisUtil {
//
//    @Autowired
//    private JedisPool jedisPool;
//
//    @Autowired
//    private RedissonClient redisson;
//
//    private static final String LOCK_TITLE = "redisLock_";
//
//    private <R> R operate(Function<Jedis,R> f){
//        Jedis jedis = null;
//        try{
//            jedis = jedisPool.getResource();
//            return f.apply(jedis);
//        }catch (JedisConnectionException e){
//            if(jedis!=null){
//                jedis.close();
//            }
//            e.printStackTrace();
//            return null;
//        }finally {
//            if(jedis!=null){
//                jedis.close();
//            }
//        }
//    }
//
//    /**
//     * 根据key查看是否存在
//     * @param key
//     * @return
//     */
//    public  boolean hasKey(String key){
//
//        return operate(j ->j.exists(key));
//    }
//
//    /**
//     * 设置key -value 形式数据
//     * @param key
//     * @param value
//     * @return
//     */
//    public  String set(String key,String value){
//        return operate(j->j.set(key,value));
//    }
//
//    /**
//     * 设置 一个过期时间
//     * @param key
//     * @param value
//     * @param timeOut 单位秒
//     * @return
//     */
//    public  String set(String key,String value,int timeOut){
//        return operate(j->j.setex(key,timeOut,value));
//    }
//
//    /**
//     * 根据key获取value
//     * @param key
//     * @return
//     */
//    public  String get(String key){
//        return operate(j->j.get(key));
//    }
//
//
//    /**
//     * 根据通配符获取所有匹配的key
//     * @param pattern
//     * @return
//     */
//    public  Set<String> getKesByPattern(String pattern){
//        return operate(jedis -> jedis.keys(pattern));
//    }
//
//    /**
//     * 根据key删除
//     * @param key
//     */
//    public  void remove(String key){
//        operate(jedis -> jedis.del(key));
//    }
//
//    /**
//     * 根据key获取过期时间
//     * @param key
//     * @return
//     */
//    public  long getTimeOutByKey(String key){
//        return operate(j->j.ttl(key));
//    }
//
//    /**
//     * 清空数据 【慎用啊！】
//     */
//    public  void flushDB(){
//        operate(j->j.flushDB());
//    }
//
//    /**
//     * 刷新过期时间
//     * @param key
//     * @param timeOut
//     * @return
//     */
//    public  long refreshLiveTime(String key,int timeOut){
//        return operate(j->j.expire(key,timeOut));
//    }
//
//    public Long  addAndGet(String key){
//        RAtomicLong atomicLong = redisson.getAtomicLong(key);
//        return atomicLong.incrementAndGet();
//    }
//
//    public long hset(String key,String field,String value){
//        return operate(j->j.hset(key,field,value));
//    }
//
//    public String hget(String key,String field){
//        return operate(j->j.hget(key,field));
//    }
//
//    public long hdel(String key, String field){
//        return operate(j->j.hdel(key,field));
//    }
//
//
//    public Map<String, String> hgetAll(String key){
//        return operate(j->j.hgetAll(key));
//    }
//
//    public Long sadd(String key,String... value){
//        Preconditions.checkArgument(value != null || value.length > 0);
//        return operate(j->j.sadd(key,value));
//    }
//
//    public Boolean sismember(String key,String member){
//        Preconditions.checkArgument(StringUtils.isNotEmpty(member));
//        return operate(j->j.sismember(key,member));
//    }
//
//    public Long sremove(String key){
//        String[] members = operate(j->j.smembers(key).toArray(new String[0]));
//        if(members != null && members.length > 0){
//            return operate(j-> j.srem(key,members));
//        }
//        return 0L;
//    }
//
//    public Set<String> keys(String pattern){
//        return operate(j->j.keys(pattern));
//    }
//
//    public boolean setnx(String key , String value){
//        return this.operate(j -> j.setnx(key , value)).longValue() > 0 ? true : false;
//    }
//
//    public boolean expire(String key , int ttl_seconds){
//        return this.operate(jedis -> jedis.expire(key,ttl_seconds)).longValue() > 0 ? true : false;
//    }
//    public boolean lock(String key , String value , int ttl_seconds){
//        boolean r = this.setnx(key , value);
//        if(r && ttl_seconds > 0){
//            this.expire(key , ttl_seconds);
//        }
//        return r;
//    }
//    public void unlock(String key){
//        this.remove(key);
//    }
//
//    /**
//     * @param key
//     * @param limit
//     * @return max value is limit, e.g. limit is 100,return max value 99
//     */
//    public String getNoFillWhiteSpace(String key,Long limit) {
//        RAtomicLong atomicLong = redisson.getAtomicLong(key);
//
//        if(atomicLong.getAndIncrement() == limit -1){
//            atomicLong.set(1L);//reset to 1;
//        }
//        Long v = atomicLong.get();
//        int a = String.valueOf(v).length();
//        int b = String.valueOf(limit).length();
//        StringBuilder sb = new StringBuilder();
//        while(a < b -1){
//            sb.append("0");
//            a++;
//        }
//        return sb.append(v).toString();
//    }
//
//    //加锁,需要分布式锁的时候尽量使用该方法
//    public boolean acquire(String lockName){
//        //声明key对象
//        String key = LOCK_TITLE + lockName;
//        //获取锁对象
//        RLock mylock = redisson.getLock(key);
//        //加锁，并且设置锁过期时间，防止死锁的产生
//        mylock.lock(2, TimeUnit.MINUTES);
//        System.err.println("======lock======"+Thread.currentThread().getName());
//        //加锁成功
//        return  true;
//    }
//    //锁的释放
//    public void release(String lockName){
//        //必须是和加锁时的同一个key
//        String key = LOCK_TITLE + lockName;
//        //获取所对象
//        RLock mylock = redisson.getLock(key);
//        //释放锁（解锁）
//        mylock.unlock();
//        System.err.println("======unlock======"+Thread.currentThread().getName());
//    }
//
//    /**
//     * redis实现流式队列生产者
//     * @param var1 redis key
//     * @param var2 time-sequence 时间+序列
//     * @param var3 map
//     * @return
//     */
//    public StreamEntryID addMessageToStream(String var1, StreamEntryID var2, Map<String, String> var3) {
//        return operate(j -> j.xadd(var1, var2, var3));
//    }
//
//    /**
//     * redis实现流式队列消费者
//     * @param var1  redis key
//     * @param var2  开始id
//     * @param var3  结束id
//     * @param var4  读取数量
//     */
//    public List<StreamEntry> getMessageFromStream(String var1, StreamEntryID var2, StreamEntryID var3, int var4){
//        return operate(j -> j.xrange(var1,var2,var3,var4));
//    }
//
//    public long deleteMessageFromStream(String var1, StreamEntryID... var2){
//        return operate(j -> j.xdel(var1,var2));
//    }
//}
